package com.whfp.coky.ble

import android.bluetooth.BluetoothGatt
import androidx.lifecycle.LifecycleOwner
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Observer
import com.clj.fastble.data.BleDevice
import com.clj.fastble.exception.BleException
import com.whfp.afs330h_sdk.callback.BaseNotifyCallback
import com.whfp.afs330h_sdk.callback.ConnectCallback
import com.whfp.afs330h_sdk.zx
import com.whfp.coky.ble.listener.DevListener
import com.whfp.coky.ble.listener.WzxListener
import com.whfp.coky.ble.print.PrintBtController
import com.whfp.coky.ui.base.BaseActivity
import com.whfp.coky.ui.task.model.CheckDeviceBean

/**
 *
 * 蓝牙控制者,
 * 1、处理蓝牙前序逻辑bleStatus
 * 2、处理蓝牙ble连接回调conncalback(没有写onError)
 * 3、开启通知，获取
 * created by coky on 2022/3/28
 *
 *
 * -----蓝牙连接
 * 1、isBleOpend 判断蓝牙是否开启；
 * 2、beginConn 根据类型DEV_TYPE进行开始连接；
 * 3、startConn（act） 判断连接状态，进行断开和连接操作（连接操作进入扫码界面）
 * 4、devCheck（vm） 扫码返回结果进行设备检测
 * 5、doConn 获取合规设备后进行区分设备连接
 * 6、连接成功后：
 * --->DEV:openNotify，开启监听
 * --->PRINT:拿到mPrinter = myOpertion!!.printer
 *
 * ----蓝牙传输回调监听
 *
 *
 */
abstract class BleController(
    var activity: BaseActivity<*, *>,
    val listener: BaseNotifyCallback,
    val printListener: PrintBtController.PrintListener? = null
) : ConnectCallback(){

    enum class DEV_TYPE {//蓝牙设备类型(打印机、设备)
        PRINT, DEV
    }

    var currBleType = DEV_TYPE.DEV//当前蓝牙连接设备类型

    var isConnSuccess: Boolean = false//设备连接成功标识
    var isReConn: Boolean = false//设备重连标识

    var bleStatus = MutableLiveData<Boolean>()//蓝牙开启状态

    var currVerDev: CheckDeviceBean? = null//当前http校验的设备

    var printBt: PrintBtController? = null//按需初始化，打印机蓝牙控制器

    fun observe(activity: BaseActivity<*, *>, owner: LifecycleOwner) {
        bleStatus.observe(owner, Observer {
            if (it) {
//                蓝牙开启时
                beginConn()
            } else {
                zx.instance().openBlue()
                activity.showDialog()
                activity.postDelayed({
                    activity.hideDialog()
                    if (zx.instance().isBlueEnable) {
                        bleStatus.value = true
                    } else {
                        activity.toast("请开启蓝牙！")
                    }
                }, 1500)
            }
        })
    }

    init {
        observe(activity, activity)
        printListener?.let {
            printBt = PrintBtController(activity, it)
        }
    }


    /**
     * val listener: BaseNotifyCallback,
     * 根据参数中的listener类型开启notify
     */
    private fun doNotifyOpen() {
        when(listener){
            is DevListener -> zx.instance().openNotify(zx.instance().currentDevice, listener)
            is WzxListener -> listener.doOpenNotify()
        }
    }




    fun isBleOpend(type: DEV_TYPE) {
//        判断蓝牙是否打开
        currBleType = type
        bleStatus.value = zx.instance().isBlueEnable
    }

    //    启动连接（可以走校验...在act中处理）
    fun beginConn() {
        when (currBleType) {
            DEV_TYPE.PRINT -> {
                printBt?.let {
                    if (it.isConnSuccessPrint) {
                        it.disConnPrint()
                    } else {
                        startConn(DEV_TYPE.PRINT)
                    }
                }
            }
            DEV_TYPE.DEV -> {
                if (isConnSuccess) {
                    disConnDev()
                } else {
                    startConn(DEV_TYPE.DEV)
                }
            }
//            else -> activity.toast("连接类型错误！")
        }
    }

    fun openNotify() {
//        开启通知
        if (zx.instance().currentDevice == null) {
            activity.toast("当前持有的设备为空..")
            reConn()
//            listener.connFailed(null,object :BleException(102,"持有的当前设备为空.."){})
        } else {
//            增强通用性，完成基础连接
            doNotifyOpen()
//            zx.instance().let {
//                doNotifyOpen()
//                it.openNotify(it.currentDevice, listener)
//            }
        }
    }


    //启动连接需要区分类型
    fun doConn(bleBean: CheckDeviceBean) {
        when (currBleType) {
            DEV_TYPE.PRINT -> {
//                        连接打印机
                connPrint(bleBean.deviceMac!!)
            }
            DEV_TYPE.DEV -> {
//                          连接设备
                currVerDev = bleBean
                connDev()
            }
        }
    }

    private fun connDev() {
        currVerDev?.let {
            zx.instance().connectDeviceNoParsing(it.deviceMac, it.refType, this)
        }
    }

    fun autoConn(bleDev: BleDevice?) {//自动连接

    }

    fun reConn() {//重新连接
        activity.toast("重连中，请稍后...")
        isReConn = true
        connDev()
    }

    fun disConnDev() {

    }

    //    ----------------------------写数据--------------------------------
    fun writeProjectToDevice(bqData: String, isAutoTest: Boolean = true,isCover:Boolean = true) {
        zx.instance().currentDevice?.let {
            activity.showDialog("写入中，请稍后...")
            zx.instance().loadCloudProject(it,isCover,bqData)
        }


//    BleDevice device = zx.afs330HManager().getCurrentDevice();
//    if (device != null) {        //当前已连接
//        this.isAutoTest = isAutoTest;
//        startRxLodingDialog("写入中，请稍后...", false, "云端项目写入设备超时！", 60);
//        zx.afs330HManager().loadCloudProject(device, PreferencesUtils.getIsFGZJXM(context), bqData);
//    } else {//未连接
//        deviceNotConnectedDeal();
//    }
    }


//    ---------------------------print---------------------------------

    fun connPrint(mac: String) {
        printBt?.connPrint(mac)
    }

//        fun disConnPrint() {
//            printBt?.disConnPrint()
//        }


    //-----------启动连接的BleGattCallback，设备连接状态回调---------------------------
    override fun onStartConnect() {
        var tips = "连接中.."
        if (isReConn) {
            tips = "重连中，请稍后..."
        }
        activity.showDialog(tips)
    }

    override fun onConnectFail(bleDev: BleDevice?, bleExc: BleException?) {
        isConnSuccess = false
        activity.hideDialog()
        if (isReConn) {
            activity.toast("自动重连失败，请检查设备并尝试手动连接！")
            isReConn = false
        }
        connFailed(bleDev, bleExc)
    }

    /**
     * 连接成功，打开通知
     */
    override fun onConnectSuccess(bleDev: BleDevice?, btGatt: BluetoothGatt?, i: Int) {
        isConnSuccess = true
        isReConn = false
        activity.hideDialog()
        connSuccess(bleDev, btGatt, i)
        openNotify()
    }

    /**
     * 连接断开，异常断开需要重连
     */
    override fun onDisConnected(
        isActive: Boolean,
        bleDev: BleDevice?,
        btGatt: BluetoothGatt?,
        i: Int
    ) {
        isConnSuccess = false
        activity.hideDialog()
        disConned(isActive, bleDev, btGatt, i)
        if (!isActive) {
            reConn()
        }
    }

    //    无特殊处理
    override fun onError(var1: Int, infos: String?) {
        isReConn = false
        isConnSuccess = false
        activity.toast(infos)
    }


//    -------------------------------------openNotify后的设备交互回调----------------------------
//    /**
//     * 设备错误..
//     * 未匹配项目卡时,云端下载对应的项目卡（other为项目卡名称）
//     */
//    override fun onDeviceError(code: Int, message: String?, other: String?) {
//        activity.toast(message)
//        activity.hideDialog()
//        if (code == 20202 && !other.isNullOrEmpty()) { //未匹配项目卡
//            listener.getCloudBq(other)
//        }
//    }
//
//    /**
//     * 检测完成，执行完成方法
//     * 一般情况是上次检测结果uploadResult
//     */
//    override fun onTestCompleted(result: String?) {
//        LogUtil.e("检测完成：$result");
//        activity.hideDialog()
//        listener.onTestCompleted(result)
//    }
//
//    /**
//     * 读取项目完成。
//     * 一般情况是进行项目更新，updateProj
//     */
//    override fun onReadIDCompleted(result: String?) {
//        LogUtil.e("读取设备项目和ID卡完成：$result");
//        activity.hideDialog()
//        listener.updateProj(result)
//    }
//
//    /**
//     * 加载云端项目完成。
//     * 一般情况是进行项目更新，updateProj
//     */
//    override fun onloadCouldProjectSuccess(result: String?) {
//        activity.hideDialog()
////        TipsDialog
//        LogUtil.e("加载云端项目成功：")
//        listener.updateProj(result)
//    }
//
//    /**
//     * 删除设备项目完成。
//     * 一般情况是进行项目更新，updateProj
//     */
//    override fun onDeleteDeviceProjectSuccess(result: String?) {
//        LogUtil.e("删除设备项目成功：")
//        activity.hideDialog()
//        listener.updateProj(result)
//    }
//
//    //    无特殊处理
//    override fun onDeviceStatus(deviceStatus: AFS330H_DeviceStatusBean?) {
//        LogUtil.e("试剂卡是否已插入：${deviceStatus?.getCc()}");
//        activity.hideDialog()
//    }
//
//    //    无特殊处理
//    override fun onNotifySuccess() {
//        LogUtil.e("通知订阅成功")
//    }
//
//    //    无特殊处理
//    override fun onNotifyFailure() {
//        activity.hideDialog()
//        activity.toast("通知订阅失败");
//    }
//
//    //    无特殊处理
//    override fun onWriteFailure(exception: BleException?) {
//        activity.hideDialog()
//        LogUtil.e("发送数据失败：${exception.toString()}");
//    }

    abstract fun startConn(type: DEV_TYPE)//启动连接设备

    //        gattcallback-----------
    abstract fun connFailed(bleDev: BleDevice?, bleExc: BleException?)
    abstract fun connSuccess(bleDev: BleDevice?, btGatt: BluetoothGatt?, i: Int)
    abstract fun disConned(isActive: Boolean, bleDev: BleDevice?, btGatt: BluetoothGatt?, i: Int)



//    inner class DevListener:DeviceCallback {
////        fun startConn(type: DEV_TYPE)//启动连接设备
////
////        //        gattcallback-----------
////        fun connFailed(bleDev: BleDevice?, bleExc: BleException?)
////        fun connSuccess(bleDev: BleDevice?, btGatt: BluetoothGatt?, i: Int)
////        fun disConned(isActive: Boolean, bleDev: BleDevice?, btGatt: BluetoothGatt?, i: Int)
//        /**
//         * 设备错误..
//         * 未匹配项目卡时,云端下载对应的项目卡（other为项目卡名称）
//         */
//        override fun onDeviceError(code: Int, message: String?, other: String?) {
//            activity.toast(message)
//            activity.hideDialog()
//            if (code == 20202 && !other.isNullOrEmpty()) { //未匹配项目卡
//                getCloudBq(other)
//            }
//        }
//
//        /**
//         * 检测完成，执行完成方法
//         * 一般情况是上次检测结果uploadResult
//         */
//        override fun onTestCompleted(result: String?) {
//            LogUtil.e("检测完成：$result");
//            activity.hideDialog()
//            listener.onTestCompleted(result)
//        }
//
//        /**
//         * 读取项目完成。
//         * 一般情况是进行项目更新，updateProj
//         */
//        override fun onReadIDCompleted(result: String?) {
//            LogUtil.e("读取设备项目和ID卡完成：$result");
//            activity.hideDialog()
//            listener.updateProj(result)
//        }
//
//        /**
//         * 加载云端项目完成。
//         * 一般情况是进行项目更新，updateProj
//         */
//        override fun onloadCouldProjectSuccess(result: String?) {
//            activity.hideDialog()
////        TipsDialog
//            LogUtil.e("加载云端项目成功：")
//            listener.updateProj(result)
//        }
//
//        /**
//         * 删除设备项目完成。
//         * 一般情况是进行项目更新，updateProj
//         */
//        override fun onDeleteDeviceProjectSuccess(result: String?) {
//            LogUtil.e("删除设备项目成功：")
//            activity.hideDialog()
//            listener.updateProj(result)
//        }
//
//        //    无特殊处理
//        override fun onDeviceStatus(deviceStatus: AFS330H_DeviceStatusBean?) {
//            LogUtil.e("试剂卡是否已插入：${deviceStatus?.getCc()}");
//            activity.hideDialog()
//        }
//
//        //    无特殊处理
//        override fun onNotifySuccess() {
//            LogUtil.e("通知订阅成功")
//        }
//
//        //    无特殊处理
//        override fun onNotifyFailure() {
//            activity.hideDialog()
//            activity.toast("通知订阅失败");
//        }
//
//        //    无特殊处理
//        override fun onWriteFailure(exception: BleException?) {
//            activity.hideDialog()
//            LogUtil.e("发送数据失败：${exception.toString()}");
//        }
//
//
//
//
//        //        devCallback------------
//        open fun getCloudBq(bqName: String){}//获取云端标曲
//        open fun onTestComplete(result: String?){}//测试完成
//        open fun updateProj(json: String?){}//项目更新
//
//    }
}

